home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / cgazv5n5.arc / COLLECT.H < prev    next >
C/C++ Source or Header  |  1991-09-23  |  3KB  |  78 lines
  1.   //--- COLLECT.H ------------------------ Listing 1 -----------
  2.   // A record and its container class.
  3.   // Code reuse & modifying existing classes with inheritance.
  4.   // 
  5.   // (c) 1991 C Gazette. Object code may be used freely. Source 
  6.   // code may be used as long as authorship and publication are
  7.   // explicitly acknowledged.
  8.   //------------------------------------------------------------
  9.  
  10.   #ifndef _COLLECT_H_
  11.   #define _COLLECT_H_
  12.  
  13.   #include <stdio.h>
  14.   #include <string.h>
  15.   #include <array.h>  // Object and Array class declarations
  16.  
  17.   const NameSize = 40,
  18.         DescriptionSize = 512;
  19.  
  20.   // Objects can be held in Arrays. With inheritance, 
  21.   // so can records:
  22.  
  23.   class record : public Object {
  24.     char name[NameSize], description[DescriptionSize];
  25.   public:
  26.     record ( char * Name, char * Description ) {
  27.       strncpy ( name, Name, NameSize );
  28.  
  29.       // force null termination (see strncpy)
  30.       name[NameSize - 1] = '\0';  
  31.       strncpy ( description, Description, DescriptionSize );
  32.       description[DescriptionSize - 1] = '\0';
  33.     }
  34.     char * Name()           { return name; }
  35.     char * Description()    { return description; }
  36.  
  37.     // dummy definitions for pure virtual functions:
  38.     virtual classType isA()     const { return 0; }
  39.     char * nameOf()             const { return "record"; }
  40.     hashValueType hashValue()   const { return 0; }
  41.     int isEqual(const Object&)  const { return 1; }
  42.     void printOn(ostream&)      const { }
  43.   };
  44.  
  45.   // Making a special type of Array to hold records:
  46.   class recordArray : public Array {
  47.     int size;  // change the way it keeps track of size
  48.   public:
  49.     recordArray() : Array ( 0, 0, 1 ) { size = 0; }
  50.     // Build a new one from an existing one, 
  51.     // removing the null spots:
  52.  
  53.     // The copy-constructor
  54.     recordArray(recordArray& rv) : Array ( 0, 0, 1 ) {  
  55.       size = 0;
  56.       for ( int i = 0; i < rv.arraySize(); i++ )
  57.         if ( !rv.null( i ))
  58.       add ( new record ( rv.rec ( i )));
  59.      // ( Note: record(record&) is automatically 
  60.      //   generated by compiler! )
  61.     }
  62.     // specifying the insert and fetch:
  63.     void add ( record* r ) { Array::add ( *r ); size++; }
  64.  
  65.     // use this instead of operator[]:
  66.     record& rec ( int i )  
  67.             { return (record&)Array::operator[] ( i ); }
  68.     int arraySize()     { return size; }  // redefinition
  69.     void destroy ( int i ) {
  70.       Array::destroy ( i );
  71.       theArray[i] = 0;
  72.     }
  73.     // is this slot empty?
  74.     int null ( int i )     { return ! ( theArray[i] ); }  
  75.   };
  76.  
  77.   #endif // _COLLECT_H_
  78.